frappe.ui.form.on('Work Order', {
    production_item: function(frm) {
        if(!frm.doc.production_item || !frm.doc.company) return;
        
        // 使用setTimeout延迟执行，让标准代码先完成所有操作
        setTimeout(function() {
            if(frm.doc.production_item) {
                // 查询匹配的物料默认值
                frappe.call({
                    method: "frappe.client.get_list",
                    args: {
                        doctype: "Item Default",
                        filters: {
                            "parent": frm.doc.production_item,
                            "company": frm.doc.company
                        },
                        parent: "Item",
                        fields: ["custom_default_plant_floor"]
                    },
                    callback: function(r) {
                        if(r.message && r.message.length > 0 && r.message[0].custom_default_plant_floor) {
                            frm.set_value('custom_plant_floor', r.message[0].custom_default_plant_floor);
                        }
                    }
                });
            }
        }, 500); // 延迟500毫秒
    },
    
    company: function(frm) {
        frm.trigger('production_item');
    },
    
    // 添加车间字段变化的处理器
    custom_plant_floor: function(frm) {
        if(!frm.doc.custom_plant_floor) return;
        
        // 查询车间文档以获取仓库信息
        frappe.call({
            method: "frappe.client.get",
            args: {
                doctype: "Plant Floor",
                name: frm.doc.custom_plant_floor
            },
            callback: function(r) {
                if(r.message) {
                    let plant_floor = r.message;
                    
                    // 如果车间有定义相关仓库，则更新工单的仓库字段
                    let fields_to_update = {};
                    
                    // 使用正确的字段名进行条件检查和赋值
                    if(plant_floor.warehouse) 
                        fields_to_update.wip_warehouse = plant_floor.warehouse;

                    if(plant_floor.custom_default_source_warehouse) 
                        fields_to_update.source_warehouse = plant_floor.custom_default_source_warehouse;
                    
                    if(plant_floor.custom_default_finished_goods_warehouse) 
                        fields_to_update.fg_warehouse = plant_floor.custom_default_finished_goods_warehouse;
                    
                    if(plant_floor.custom_default_scrap_warehouse) 
                        fields_to_update.scrap_warehouse = plant_floor.custom_default_scrap_warehouse;
                    
                    // 如果有字段需要更新，一次性设置多个值
                    if(Object.keys(fields_to_update).length > 0) {
                        frm.set_value(fields_to_update);
                    }
                }
            }
        });
    },
    
    // 当工单数量变化时，更新所有工序的价格和成本
    qty: function(frm) {
        if (frm.doc.operations && frm.doc.operations.length > 0) {
            frm.doc.operations.forEach(function(row) {
                update_operation_price(frm, row);
            });
        }
    },
    
    // 当BOM变化时，系统会自动重新加载工序，所以不需要在这里处理
    bom_no: function(frm) {
        // BOM变化后，系统会自动重新加载工序
    }
});

// 扩展Work Order Operation子表功能
frappe.ui.form.on('Work Order Operation', {
    operations_remove: function(frm) {
        update_total_planned_costs(frm);
    },
    // 当工序变化时
    operation: function(frm, cdt, cdn) {
        let row = locals[cdt][cdn];
        update_operation_price(frm, row);
    },
    
    // 当工作中心变化时
    workstation: function(frm, cdt, cdn) {
        let row = locals[cdt][cdn];
        update_operation_price(frm, row);
    },
    
    // 当供应商变化时
    custom_supplier: function(frm, cdt, cdn) {
        let row = locals[cdt][cdn];
        update_operation_price(frm, row);
    },
    
    // 当计价方式变化时
    custom_rate_type: function(frm, cdt, cdn) {
        let row = locals[cdt][cdn];
        update_operation_price(frm, row);
    },
    
    // 当工时变化时
    time_in_mins: function(frm, cdt, cdn) {
        let row = locals[cdt][cdn];
        // 如果是计时模式，更新价格
        if (row.custom_rate_type === "By Hour") {
            update_operation_price(frm, row);
        }
    },
    
    // 添加新的处理函数：当含税单价变化时
    custom_service_price_with_tax: function(frm, cdt, cdn) {
        let row = locals[cdt][cdn];
        if (row.custom_service_price_with_tax && row.custom_tax_rate) {
            // 计算不含税单价 = 含税单价 / (1 + 税率/100)
            let tax_rate = row.custom_tax_rate / 100;
            let price_without_tax = flt(row.custom_service_price_with_tax / (1 + tax_rate));
            
            // 检查新值是否与当前值相同（避免循环触发）
            if (Math.abs(flt(row.custom_service_price - price_without_tax)) > 0.001) {
                // 设置标志，表示这是由含税单价触发的更新
                row._updating_from_tax_price = true;
                
                // 更新不含税单价字段
                frappe.model.set_value(cdt, cdn, 'custom_service_price', price_without_tax);
                
                // 清除标志
                setTimeout(() => {
                    row._updating_from_tax_price = false;
                }, 0);
            }
        }
    },
    
    // 当税率变化时
    custom_tax_rate: function(frm, cdt, cdn) {
        let row = locals[cdt][cdn];
        if (row.custom_service_price_with_tax && row.custom_tax_rate) {
            // 计算不含税单价 = 含税单价 / (1 + 税率/100)
            let tax_rate = row.custom_tax_rate / 100;
            let price_without_tax = flt(row.custom_service_price_with_tax / (1 + tax_rate));
            
            // 检查新值是否与当前值相同（避免循环触发）
            if (Math.abs(flt(row.custom_service_price - price_without_tax)) > 0.001) {
                // 更新不含税单价字段
                frappe.model.set_value(cdt, cdn, 'custom_service_price', price_without_tax);
            }
        } else if (row.custom_service_price && row.custom_tax_rate) {
            // 如果没有含税单价但有不含税单价和税率，计算含税单价
            let tax_rate = row.custom_tax_rate / 100;
            let price_with_tax = flt(row.custom_service_price * (1 + tax_rate));
            
            // 检查新值是否与当前值相同（避免循环触发）
            if (Math.abs(flt(row.custom_service_price_with_tax - price_with_tax)) > 0.001) {
                // 更新含税单价字段
                frappe.model.set_value(cdt, cdn, 'custom_service_price_with_tax', price_with_tax);
            }
        }
    },
    
    // 当不含税单价变化时，更新含税单价和计划成本
    custom_service_price: function(frm, cdt, cdn) {
        let row = locals[cdt][cdn];
        
        // 如果这是由含税单价触发的更新，不要再触发回去
        if (row._updating_from_tax_price) {
            return;
        }
        
        // 1. 更新含税单价
        if (row.custom_service_price && row.custom_tax_rate) {
            // 计算含税单价 = 不含税单价 * (1 + 税率/100)
            let tax_rate = row.custom_tax_rate / 100;
            let price_with_tax = flt(row.custom_service_price * (1 + tax_rate));
            
            // 检查新值是否与当前值相同（避免循环触发）
            if (Math.abs(flt(row.custom_service_price_with_tax - price_with_tax)) > 0.001) {
                // 更新含税单价字段
                frappe.model.set_value(cdt, cdn, 'custom_service_price_with_tax', price_with_tax);
            }
        }
        
        // 2. 根据计价方式更新计划成本
        if (row.custom_service_price > 0) {
            if (row.custom_rate_type === "By Qty") {
                // 计件：成本 = 单价 * 数量
                let labour_cost = flt(row.custom_service_price * frm.doc.qty);
                frappe.model.set_value(cdt, cdn, 'custom_planned_labour_cost', labour_cost);
            } else if (row.custom_rate_type === "By Hour") {
                // 计时：成本 = 单价 * (时间分钟 / 60)
                let labour_cost = flt(row.custom_service_price * row.time_in_mins / 60);
                frappe.model.set_value(cdt, cdn, 'custom_planned_labour_cost', labour_cost);
            } else if (row.custom_rate_type === "Subcontracting") {
                // 委外：成本 = 单价 * 数量
                let subcontracting_cost = flt(row.custom_service_price * frm.doc.qty);
                frappe.model.set_value(cdt, cdn, 'custom_planned_subcontracting_cost', subcontracting_cost);
            }
        }
        
        // 在所有更新完成后，最后更新总成本
        setTimeout(() => update_total_planned_costs(frm), 500);
    },
    
    // 当工序被移除时
    remove: function(frm) {
        update_total_planned_costs(frm);
    }
});

// 统一的工序价格更新函数，根据计价方式调用不同的价格获取逻辑
function update_operation_price(frm, row) {
    // 检查必要字段是否已填写
    if (!frm.doc.company || !frm.doc.production_item || !row.operation) {
        return;
    }
    
    // 根据计价方式处理
    if (row.custom_rate_type === "Subcontracting") {
        // 委外方式需要供应商
        if (!row.custom_supplier) {
            return;
        }
        update_subcontracting_price(frm, row);
    } 
    else if (row.custom_rate_type === "By Hour" || row.custom_rate_type === "By Qty") {
        // 计时/计件方式
        update_hourly_or_qty_price(frm, row);
    }
    
    // 添加这一行 - 确保在任何价格更新后，总计也被更新
    setTimeout(() => update_total_planned_costs(frm), 500);
}

// 更新委外单价的函数
function update_subcontracting_price(frm, row) {
    // 检查必要字段是否已填写
    if (!frm.doc.company || !frm.doc.production_item || !row.operation || !row.custom_supplier || !frm.doc.qty) {
        return;
    }
    
    // 调用后端方法获取委外单价
    frappe.call({
        method: "light_mes.light_mes.doctype.subcontracting_service_price.subcontracting_service_price.get_subcontracting_price",
        args: {
            company: frm.doc.company,
            supplier: row.custom_supplier,
            qty: frm.doc.qty, // 使用工单的数量
            item_code: frm.doc.production_item, // 使用工单的物料
            operation: row.operation,
            // 使用当前日期
            price_date: frappe.datetime.get_today()
        },
        callback: function(r) {
            if (r.message !== undefined) {
                // 更新单价字段
                frappe.model.set_value(row.doctype, row.name, 'custom_service_price', r.message);
                
                // 如果价格为0，显示提示
                if (r.message === 0) {
                    frappe.show_alert({
                        message: __('No subcontracting price found for the selected item, operation and supplier.'),
                        indicator: 'orange'
                    });
                }
                
                // 如果有税率，同时更新含税单价
                if (row.custom_tax_rate) {
                    let tax_rate = row.custom_tax_rate / 100;
                    let price_with_tax = flt(r.message * (1 + tax_rate));
                    frappe.model.set_value(row.doctype, row.name, 'custom_service_price_with_tax', price_with_tax);
                }
                
                // 更新委外计划成本
                if (r.message > 0) {
                    let subcontracting_cost = flt(r.message * frm.doc.qty);
                    frappe.model.set_value(row.doctype, row.name, 'custom_planned_subcontracting_cost', subcontracting_cost);
                    

                }
            }
        }
    });
}

// 更新计时/计件单价的函数
function update_hourly_or_qty_price(frm, row) {
    if (!row.operation) {
        return;
    }
    
    // 创建row的一个干净副本，避免循环引用和非JSON序列化属性
    let operation_data = {};
    
    // 复制所有非函数、非下划线开头的属性
    for (let key in row) {
        if (
            typeof row[key] !== 'function' && // 排除方法
            !key.startsWith('_') && // 排除内部属性
            row[key] !== undefined && // 排除undefined值
            row[key] !== null // 排除null值
        ) {
            operation_data[key] = row[key];
        }
    }
    
    // 添加主表信息
    let parent_doc = {};
    for (let key in frm.doc) {
        if (
            typeof frm.doc[key] !== 'function' && // 排除方法
            !key.startsWith('_') && // 排除内部属性
            !Array.isArray(frm.doc[key]) && // 排除子表
            frm.doc[key] !== undefined && // 排除undefined值
            frm.doc[key] !== null // 排除null值
        ) {
            parent_doc[key] = frm.doc[key];
        }
    }
    operation_data.parent_doc = parent_doc;
    
    // 调用后端方法获取工序单价
    frappe.call({
        method: "light_mes.light_mes.doctype.operation_price_strategy.operation_price_strategy.get_operation_price_for_bom",
        args: {
            product: frm.doc.production_item,
            operation: operation_data,
            price_date: frappe.datetime.get_today()
        },
        callback: function(r) {
            if (r.message !== undefined) {
                // 更新单价字段
                frappe.model.set_value(row.doctype, row.name, 'custom_service_price', r.message);
                
                // 如果价格为0，显示提示
                if (r.message === 0) {
                    frappe.show_alert({
                        message: __(`No service price found for the selected row.`),
                        indicator: 'orange'
                    });
                }
                
                // 更新计划人工成本
                if (r.message > 0) {
                    let labour_cost = 0;
                    if (row.custom_rate_type === "By Hour") {
                        // 计时：成本 = 单价 * (时间分钟 / 60)
                        labour_cost = flt(r.message * row.time_in_mins / 60);
                    } else if (row.custom_rate_type === "By Qty") {
                        // 计件：成本 = 单价 * 数量
                        labour_cost = flt(r.message * frm.doc.qty);
                    }
                    frappe.model.set_value(row.doctype, row.name, 'custom_planned_labour_cost', labour_cost);
                }
            }
        }
    });
}

// 覆盖 ERPNext 原始的总成本计算方法
erpnext.work_order.calculate_total_cost = function(frm) {
    let variable_cost = flt(frm.doc.actual_operating_cost) || flt(frm.doc.planned_operating_cost);
    
    // 添加计划委外成本
    let subcontracting_cost = flt(frm.doc.custom_subcontracting_fee) || flt(frm.doc.custom_planned_subcontracting_cost);
    
    // 添加计划人工成本
    let labour_cost = flt(frm.doc.custom_actual_labour_cost) || flt(frm.doc.custom_planned_labour_cost);
    
    // 计算总成本：原有的变动成本 + 额外运营成本 + 委外成本 + 人工成本
    let total_cost = flt(frm.doc.additional_operating_cost) + variable_cost + subcontracting_cost + labour_cost;
    
    // 设置总运营成本
    frm.set_value("total_operating_cost", total_cost);

};

// 在update_total_planned_costs函数末尾添加对总成本计算的调用
function update_total_planned_costs(frm) {
    // 只有当操作表格存在且有内容时才继续
    if (!frm.doc.operations || !frm.doc.operations.length) {
        return;
    }
    
    // 初始化总成本变量
    let total_labour_cost = 0;
    let total_subcontracting_cost = 0;
    
    // 遍历所有工序行，累加计划成本
    frm.doc.operations.forEach(function(row) {
        // 累加计划人工成本
        if (row.custom_planned_labour_cost) {
            total_labour_cost += flt(row.custom_planned_labour_cost);
        }
        
        // 累加计划委外成本
        if (row.custom_planned_subcontracting_cost) {
            total_subcontracting_cost += flt(row.custom_planned_subcontracting_cost);
        }
    });
    
    // 更新工单主表的总成本字段
    frm.set_value('custom_planned_labour_cost', total_labour_cost);
    frm.set_value('custom_planned_subcontracting_cost', total_subcontracting_cost);
    
    // 调用覆盖后的总成本计算方法
    erpnext.work_order.calculate_total_cost(frm);
} 